NumPy massiivioperatsioonid: põhjalik juhend matemaatilisteks arvutusteks

NumPy, lühend sõnadest Numerical Python, on Pythoni teadusarvutuste põhipakett. See pakub võimsaid tööriistu numbriliste andmetega, eriti massiividega töötamiseks. See juhend uurib NumPy massiivioperatsioonide põhiaspekte matemaatilistes arvutustes, pakkudes globaalset perspektiivi ja praktilisi näiteid, et anda volitusi andmeteadlastele, inseneridele ja teadlastele üle maailma.

Sissejuhatus NumPy massiividesse

Oma olemuselt tutvustab NumPy ndarray objekti, mitmemõõtmelist massiiviobjekti, mis on numbriliste operatsioonide jaoks tõhusam ja mitmekülgsem kui Pythoni sisseehitatud loendid. Massiivid on homogeensed andmestruktuurid – see tähendab, et elemendid jagavad tavaliselt sama andmetüüpi (nt täisarvud, ujukomaarvud). See homogeensus on jõudluse optimeerimiseks ülioluline.

NumPy-ga alustamiseks peate selle esmalt installima (kui teil seda veel pole):

            pip install numpy
            

              
                Copy
              
            
          

Seejärel importige pakett oma Pythoni keskkonda:

            import numpy as np
            

              
                Copy
              
            
          

np alias on laialt levinud tava ja muudab teie koodi loetavamaks.

NumPy massiivide loomine

Massiive saab luua loenditest, ennikutest ja muudest massiivilaadsetest objektidest. Siin on mõned näited:

• Massiivi loomine loendist:

            import numpy as np
my_list = [1, 2, 3, 4, 5]
my_array = np.array(my_list)
print(my_array) # Väljund: [1 2 3 4 5]
            

              
                Copy
              
            
          

• Mitmemõõtmelise massiivi (maatriksi) loomine:

            import numpy as np
my_matrix = [[1, 2, 3],
             [4, 5, 6],
             [7, 8, 9]]
my_array = np.array(my_matrix)
print(my_array)
# Väljund:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]
            

              
                Copy
              
            
          

• Kindlate väärtustega massiivide loomine:

            import numpy as np
zeros_array = np.zeros(5) # Loob 5 nullist koosneva massiivi: [0. 0. 0. 0. 0.]
ones_array = np.ones((2, 3)) # Loob 2x3 ühtedest koosneva massiivi: [[1. 1. 1.]
                           #                                   [1. 1. 1.]]
range_array = np.arange(0, 10, 2) # Loob massiivi 0-st 10-ni (v.a.), sammuga 2: [0 2 4 6 8]
linspace_array = np.linspace(0, 1, 5) # Loob massiivi 5 ühtlaselt jaotatud väärtusega 0-st 1-ni: [0.   0.25 0.5  0.75 1.  ]
            

              
                Copy
              
            
          

Massiivi atribuudid

NumPy massiividel on mitu atribuuti, mis annavad massiivi kohta väärtuslikku teavet:

• shape: Tagastab massiivi mõõtmed (read, veerud jne).
• dtype: Tagastab massiivi elementide andmetüübi.
• ndim: Tagastab massiivi mõõtmete (telgede) arvu.
• size: Tagastab elementide koguarvu massiivis.

            import numpy as np
my_array = np.array([[1, 2, 3], [4, 5, 6]])
print(my_array.shape)  # Väljund: (2, 3)
print(my_array.dtype)  # Väljund: int64 (või sarnane, sõltuvalt teie süsteemist)
print(my_array.ndim)   # Väljund: 2
print(my_array.size)   # Väljund: 6
            

              
                Copy
              
            
          

Põhilised massiivioperatsioonid

NumPy võimaldab teil sooritada massiividel elemendipõhiseid operatsioone, lihtsustades matemaatilisi arvutusi. Need operatsioonid on sageli oluliselt kiiremad kui samade operatsioonide teostamine Pythoni tsüklitega.

Aritmeetilised operatsioonid

Põhilised aritmeetilised operatsioonid (+, -, *, /, **) teostatakse elemendipõhiselt. Operatsioonid on vektoriseeritud, mis tähendab, et need toimivad kõigil massiivi elementidel samaaegselt.

            import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# Liitmine
c = a + b
print(c)  # Väljund: [5 7 9]

# Lahutamine
d = b - a
print(d)  # Väljund: [3 3 3]

# Korrutamine
e = a * b
print(e)  # Väljund: [ 4 10 18]

# Jagamine
f = b / a
print(f)  # Väljund: [4.  2.5 2. ]

# Astendamine
g = a ** 2
print(g)  # Väljund: [1 4 9]
            

              
                Copy
              
            
          

Hajutamine (Broadcasting)

Hajutamine (Broadcasting) on NumPy võimas mehhanism, mis võimaldab operatsioone erineva kujuga massiividega. Väiksem massiiv "hajutatakse" üle suurema massiivi, nii et neil oleksid ühilduvad kujud. See juhtub sageli kaudselt, lihtsustades koodi.

Näiteks saate massiivile liita skalaarväärtuse:

            import numpy as np
a = np.array([1, 2, 3])
result = a + 5
print(result)  # Väljund: [6 7 8]
            

              
                Copy
              
            
          

Siin hajutatakse skalaar 5 massiivi a kujule, luues tegelikult massiivi [5, 5, 5], mis seejärel liidetakse massiivile a.

Massiivi indekseerimine ja viilutamine

NumPy pakub paindlikke viise massiivi elementidele juurdepääsemiseks ja nende muutmiseks.

• Indekseerimine: Juurdepääs üksikutele elementidele nende indeksite abil.
• Viilutamine: Juurdepääs elementide vahemikule, kasutades algus-, lõpp- ja sammuväärtusi.

            import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Indekseerimine
element = a[0, 1] # Juurdepääs elemendile esimeses reas, teises veerus
print(element)  # Väljund: 2

# Viilutamine
row_slice = a[1:3, :] # Hangi read 1 ja 2, kõik veerud
print(row_slice)
# Väljund:
# [[4 5 6]
#  [7 8 9]]

col_slice = a[:, 1] # Hangi kõik read, teine veerg
print(col_slice)  # Väljund: [2 5 8]
            

              
                Copy
              
            
          

Saadaval on ka täpsem indekseerimine, näiteks tõeväärtusindekseerimine ja uhke indekseerimine (kasutades indeksite massiive), mis pakuvad veelgi suuremat kontrolli.

Matemaatilised funktsioonid

NumPy pakub laiaulatuslikku matemaatiliste funktsioonide kogumit, mis toimivad massiividel, sealhulgas trigonomeetrilised funktsioonid, eksponentsiaal- ja logaritmilised funktsioonid, statistilised funktsioonid ja palju muud.

Trigonomeetrilised funktsioonid

NumPy pakub standardseid trigonomeetrilisi funktsioone nagu sin(), cos(), tan(), arcsin(), arccos(), arctan() jne, mis toimivad elemendipõhiselt.

            import numpy as np
a = np.array([0, np.pi/2, np.pi])
sin_values = np.sin(a)
print(sin_values)  # Väljund: [0.000e+00 1.000e+00 1.225e-16] (ligikaudne, ujukomaarvutuste täpsuse tõttu)

            

              
                Copy
              
            
          

Eksponentsiaal- ja logaritmilised funktsioonid

Saadaval on ka funktsioonid nagu exp(), log(), log10() ja sqrt().

            import numpy as np
a = np.array([1, 2, 3])
exp_values = np.exp(a)
print(exp_values)
# Väljund: [ 2.71828183  7.3890561  20.08553692]

log_values = np.log(a)
print(log_values)
# Väljund: [0.         0.69314718 1.09861229]
            

              
                Copy
              
            
          

Statistilised funktsioonid

NumPy sisaldab funktsioone statistiliseks analüüsiks:

• mean(): Arvutab massiivi elementide keskmise.
• median(): Arvutab mediaani.
• std(): Arvutab standardhälbe.
• var(): Arvutab dispersiooni.
• min(): Leiab miinimumväärtuse.
• max(): Leiab maksimumväärtuse.
• sum(): Arvutab massiivi elementide summa.

            import numpy as np
a = np.array([1, 2, 3, 4, 5])
print(np.mean(a))    # Väljund: 3.0
print(np.std(a))     # Väljund: 1.4142135623730951
print(np.sum(a))    # Väljund: 15
            

              
                Copy
              
            
          

Lineaaralgebra NumPy abil

NumPy pakub võimsaid tööriistu lineaaralgebra operatsioonideks, mis on olulised erinevates valdkondades nagu masinõpe, füüsika ja inseneeria. numpy.linalg moodul sisaldab paljusid lineaaralgebra funktsionaalsusi.

Maatriksioperatsioonid

• Maatrikskorrutis: @ operaator (või np.dot()) teostab maatrikskorrutise.
• Maatriksi transponeerimine: Kasutage .T atribuuti või np.transpose().
• Determinant: np.linalg.det() arvutab ruutmaatriksi determinandi.
• Pöördmaatriks: np.linalg.inv() arvutab ruutmaatriksi, pööratava maatriksi pöördmaatriksi.

            import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

# Maatrikskorrutis
c = a @ b  # Või np.dot(a, b)
print(c)
# Väljund:
# [[19 22]
#  [43 50]]

# Maatriksi transponeerimine
d = a.T
print(d)
# Väljund:
# [[1 3]
#  [2 4]]

# Determinant
e = np.linalg.det(a)
print(e)  # Väljund: -2.0
            

              
                Copy
              
            
          

Lineaarvõrrandisüsteemide lahendamine

NumPy suudab lahendada lineaarvõrrandisüsteeme, kasutades np.linalg.solve().

            import numpy as np
# Lahendage võrrandisüsteem:
# 2x + y = 5
# x + 3y = 8

a = np.array([[2, 1], [1, 3]])
b = np.array([5, 8])
x = np.linalg.solve(a, b)
print(x)  # Väljund: [1. 3.] (ligikaudne)
            

              
                Copy
              
            
          

Omaväärtused ja omavektorid

Funktsioon np.linalg.eig() arvutab ruutmaatriksi omaväärtused ja omavektorid.

            import numpy as np
a = np.array([[1, 2], [2, 1]])
eigenvalues, eigenvectors = np.linalg.eig(a)
print('Omaväärtused:', eigenvalues)
print('Omavektorid:', eigenvectors)
            

              
                Copy
              
            
          

Praktilised näited: globaalsed rakendused

NumPy'd kasutatakse laialdaselt erinevates valdkondades üle maailma. Siin on mõned näited:

1. Pilditöötlus

Pilte esitatakse mitmemõõtmeliste massiividena, mis võimaldab tõhusat töötlemist NumPy abil. Alates põhilistest manipulatsioonidest nagu värvikorrektsioon kuni arenenud tehnikateni nagu servade tuvastamine ja objektide äratundmine (mida kasutatakse sageli arvutinägemise rakendustes üle maailma, sealhulgas Saksamaal ja Hiinas arendatavates autonoomsetes sõidukites), on NumPy selle keskmes.

            # Lihtsustatud näide:
import numpy as np
from PIL import Image  # Nõuab Pillow teeki

# Laadige pilt (asendage 'image.png' oma pildifailiga)
try:
    img = Image.open('image.png')
except FileNotFoundError:
    print('Viga: faili image.png ei leitud. Palun paigutage see samasse kausta või muutke teed.')
    exit()

img_array = np.array(img)

# Teisenda halltoonidesse (keskmista RGB kanalid)
grayscale_img = np.mean(img_array, axis=2, keepdims=False).astype(np.uint8)

# Kuvage või salvestage halltoonides pilt (nõuab teeki nagu matplotlib)
from PIL import Image
grayscale_image = Image.fromarray(grayscale_img)
grayscale_image.save('grayscale_image.png')
print('Halltoonides pilt salvestatud nimega grayscale_image.png')
            

              
                Copy
              
            
          

2. Andmeteadus ja masinõpe

NumPy on aluseks paljudele Pythoni andmeteaduse teekidele, nagu Pandas, scikit-learn ja TensorFlow. Seda kasutatakse andmete puhastamiseks, manipuleerimiseks, tunnuste loomiseks, mudelite treenimiseks ja hindamiseks. Teadlased ja praktikud üle maailma tuginevad NumPy'le ennustavate mudelite ehitamisel, andmekogumite analüüsimisel ja andmetest ülevaate saamisel, alates finantsmodelleerimisest Ameerika Ühendriikides kuni kliimauuringuteni Austraalias.

            # Näide: andmestiku keskmise arvutamine
import numpy as np
data = np.array([10, 12, 15, 18, 20])
mean_value = np.mean(data)
print(f'Andmete keskmine on: {mean_value}')
            

              
                Copy
              
            
          

3. Teadusarvutused

Teadlased ja insenerid üle maailma, alates Euroopa Kosmoseagentuurist kuni India teadusasutusteni, kasutavad NumPy'd simulatsioonideks, modelleerimiseks ja andmeanalüüsiks. Näiteks kasutavad nad seda vedelike dünaamika simuleerimiseks, eksperimentaalsete andmete analüüsimiseks ja numbriliste algoritmide arendamiseks.

            # Näide: lihtsa füüsikalise süsteemi simuleerimine
import numpy as np
# Määratle aja parameetrid
time = np.linspace(0, 10, 100)  # Aeg 0 kuni 10 sekundit, 100 punkti

# Määratle parameetrid (näide: konstantne kiirendus)
acceleration = 9.8  # m/s^2 (gravitatsioonikiirendus)
initial_velocity = 0  # m/s
initial_position = 0  # m

# Arvuta asukoht ajas, kasutades kinemaatilist võrrandit:  x = x0 + v0*t + 0.5*a*t^2
position = initial_position + initial_velocity * time + 0.5 * acceleration * time**2

# Väljasta tulemused (joonistamiseks jne)
print(position)
            

              
                Copy
              
            
          

4. Finantsmodelleerimine

Finantsanalüütikud kasutavad NumPy'd selliste ülesannete jaoks nagu portfelli optimeerimine, riskijuhtimine ja finantsmodelleerimine. Seda kasutatakse investeerimisühingutes üle maailma, sealhulgas Šveitsis ja Jaapanis, suurte andmekogumite käsitlemiseks ja keerukate arvutuste tõhusaks teostamiseks.

            # Näide: liitkasvumäära (CAGR) arvutamine
import numpy as np
initial_investment = 10000 # USD
final_value = 15000   # USD
number_of_years = 5  # Aastat

# Arvuta CAGR
cagr = ( (final_value / initial_investment)**(1 / number_of_years) - 1 ) * 100
print(f'CAGR on: {cagr:.2f}%')
            

              
                Copy
              
            
          

NumPy koodi optimeerimine

Et NumPy jõudlusest maksimumi võtta, kaaluge neid näpunäiteid:

• Vektoriseerimine: Vältige võimaluse korral otseseid Pythoni tsükleid; NumPy operatsioonid on vektoriseeritud ja oluliselt kiiremad.
• Andmetüübid: Valige sobivad andmetüübid mälukasutuse minimeerimiseks.
• Massiivi vaated: Kasutage massiivi vaateid (nt viilutamine) massiivide kopeerimise asemel, et vältida tarbetut mälukasutust.
• Vältige tarbetuid koopiaid: Olge teadlik operatsioonidest, mis loovad koopiaid (nt kasutades array.copy()).
• Kasutage sisseehitatud funktsioone: Kasutage NumPy optimeeritud sisseehitatud funktsioone alati, kui need on saadaval (nt np.sum(), np.mean()).

Kokkuvõte

NumPy on teadusarvutuste ja andmeanalüüsi nurgakivi. NumPy massiivioperatsioonide valdamine annab teile võime tõhusalt käsitleda numbrilisi andmeid, sooritada keerukaid arvutusi ja arendada uuenduslikke lahendusi erinevates valdkondades. Selle ülemaailmne kasutuselevõtt peegeldab selle mitmekülgsust ja olulist rolli tänapäeva andmepõhistes püüdlustes. See juhend loob aluse NumPy rikaste võimaluste ja selle rakenduste uurimiseks maailmas, kus andmed on progressi keskmes.

Lisalugemist

Õppimise jätkamiseks kaaluge neid ressursse:

• NumPy dokumentatsioon: Ametlik NumPy dokumentatsioon on põhjalik ja detailne. https://numpy.org/doc/stable/
• Veebikursused: Platvormid nagu Coursera, edX ja Udemy pakuvad arvukalt kursusi NumPy ja andmeteaduse kohta.
• Raamatud: Uurige raamatuid Pythoni kohta andmeteaduses ja teadusarvutustes, mis sageli sisaldavad peatükke NumPy kohta.
• Praktika: Töötage läbi näidisülesandeid ja projekte, et oma arusaamist kinnistada. Kaggle ja teised platvormid pakuvad andmekogumeid ja väljakutseid harjutamiseks.